Learning objectives

By the end of this lecture, you will be able to:

1. Create reproducible documents with Quarto
2. Organise projects using R Projects
3. Use Git and GitHub for version control
4. Import data from various file formats

What is reproducibility?

Why does reproducibility matter?

The reproducibility crisis

Many published findings cannot be reproduced:

• Psychology: ~40% of studies replicate
• Cancer biology: ~10-25% replicate
• Economics: ~50% replicate

Components of reproducible research

1. Code — Scripts that transform data into results
2. Data — Raw and processed datasets
3. Environment — Software versions and dependencies
4. Documentation — Explanations of decisions and methods

What is Quarto?

Why use Quarto?

Creating a Quarto document

In RStudio:

1. File → New File → Quarto Document…
2. Add a title and your name
3. Unclick “Use visual markdown editor” (for now)
4. Click Create

The structure of a Quarto document

A Quarto document has three parts:

1. YAML header — Document settings (between ---)
2. Markdown text — Your written content
3. Code chunks — Executable R code

---
title: "My Analysis"
author: "Your Name"
format: html
---

# Introduction

Some text here.

1 + 1

[1] 2

## YAML header basics

The YAML header controls document settings:

```yaml
---
title: "My document"
author: "Rohan Alexander"
date: today
format: html
---

Adding references

Include a bibliography file in the YAML:

---
title: "My document"
bibliography: references.bib
---

Essential Markdown commands

# First level
## Second level
### Third level

- Item 1
- Item 2
  + Sub-item

[text](https://url.com)

Code chunks

Code chunks contain R code that will execute:

```{r}
# Calculate the mean of some numbers
mean(c(1, 2, 3, 4, 5))
```

# Calculate the mean of some numbers
mean(c(1, 2, 3, 4, 5))

[1] 3

Chunk options

Control how chunks behave with special comments:

```{r}
#| echo: false
#| warning: false
#| message: false

library(tidyverse)
```

Example: Including a graph

```{r}
#| label: fig-example
#| fig-cap: "A simple scatterplot"
#| echo: false

mtcars |>
  ggplot(aes(x = wt, y = mpg)) +
  geom_point() +
  theme_minimal()
```

Figure 1: A simple scatterplot

Cross-references

Reference figures and tables by their label:

• Figures: @fig-labelname → Figure 1
• Tables: @tbl-labelname → Table 1
• Equations: @eq-labelname → Equation 1

Rendering your document

Click the Render button (or press Ctrl/Cmd + Shift + K)

Why use R Projects?

What is an R Project?

An R Project is a folder with a special .Rproj file that tells RStudio:

• This is a project
• Set the working directory here
• Keep project-specific settings

Creating an R Project

In RStudio:

1. File → New Project…
2. Select New Directory or Existing Directory
3. Give it a meaningful name
4. Click Create Project

Recommended folder structure

my_project/
├── my_project.Rproj
├── README.md
├── inputs/
│   ├── data/
│   │   └── raw_data.csv
│   └── literature/
├── outputs/
│   ├── data/
│   │   └── cleaned_data.csv
│   └── paper/
│       ├── paper.qmd
│       └── references.bib
└── scripts/
    ├── 00-simulate_data.R
    ├── 01-download_data.R
    ├── 02-clean_data.R
    └── 03-test_data.R

Folder structure explained

The README file

Every project needs a README that explains:

1. What the project is about
2. How the files are organised
3. How to reproduce the analysis
4. Where the data came from

The working directory

Your working directory is where R looks for files by default.

# Check your working directory
getwd()

# Set working directory (avoid this!)
setwd("path/to/folder")

Reading CSV files

CSV (Comma-Separated Values) is the most common data format:

# Base R
data <- read.csv("inputs/data/mydata.csv")

# Tidyverse (recommended)
library(readr)
data <- read_csv("inputs/data/mydata.csv")

Reading other file types

# Tab-separated files
data <- read_tsv("data.tsv")

# Files with other delimiters
data <- read_delim("data.txt", delim = "|")

# Excel files (need readxl package)
library(readxl)
data <- read_excel("data.xlsx")

# Space-separated (base R)
data <- read.table("data.txt", header = TRUE)

The header argument

Many data files have column names in the first row:

# First row contains column names
data <- read.table("data.txt", header = TRUE)

# First row is data (no column names)
data <- read.table("data.txt", header = FALSE)

Writing data

Save your processed data:

# Save as CSV (tidyverse)
write_csv(cleaned_data, "outputs/data/cleaned_data.csv")

# Save as CSV (base R)
write.csv(cleaned_data, "outputs/data/cleaned_data.csv")

# Save R object (preserves data types)
saveRDS(cleaned_data, "outputs/data/cleaned_data.rds")

Examining your data

After loading data, always check it:

# First few rows
head(data)

# Last few rows
tail(data)

# Structure and types
str(data)

# Dimensions
nrow(data)  # Number of rows
ncol(data)  # Number of columns
dim(data)   # Both

# Column names
names(data)

Example: Reading and examining data

# Create some example data
example_data <- tibble(
  name = c("Alice", "Bob", "Carol"),
  age = c(25, 30, 35),
  score = c(85.5, 92.0, 78.5)
)

# Examine it
head(example_data)

# A tibble: 3 × 3
  name    age score
  <chr> <dbl> <dbl>
1 Alice    25  85.5
2 Bob      30  92  
3 Carol    35  78.5

names(example_data)

[1] "name"  "age"   "score"

Accessing columns

Two ways to access a column:

# Using $ notation
example_data$age

[1] 25 30 35

# Using bracket notation
example_data[, "age"]

# A tibble: 3 × 1
    age
  <dbl>
1    25
2    30
3    35

Vectors

A vector is a list of items of the same type:

# Create vectors
numbers <- c(1, 2, 3, 4, 5)
names <- c("Alice", "Bob", "Carol")

# Sequences
1:10

 [1]  1  2  3  4  5  6  7  8  9 10

seq(0, 100, by = 10)

 [1]   0  10  20  30  40  50  60  70  80  90 100

Operations on vectors

Mathematical operations work element-by-element:

x <- c(1, 2, 3)
y <- c(10, 20, 30)

x + y    # Addition

[1] 11 22 33

x * y    # Multiplication

[1] 10 40 90

x^2      # Power

[1] 1 4 9

Summarising vectors

values <- c(10, 20, 30, 40, 50)

sum(values)      # Total

[1] 150

mean(values)     # Average

[1] 30

length(values)   # Count

[1] 5

Missing values

R represents missing data as NA:

data_with_missing <- c(1, 2, NA, 4, 5)

# Many functions return NA if data contains NA
mean(data_with_missing)

[1] NA

# Use na.rm = TRUE to ignore missing values
mean(data_with_missing, na.rm = TRUE)

[1] 3

Subsetting with brackets

Access specific elements with [ ]:

letters_example <- c("A", "B", "C", "D", "E")

letters_example[1]        # First element

[1] "A"

letters_example[c(1, 3)]  # First and third

[1] "A" "C"

letters_example[2:4]      # Second through fourth

[1] "B" "C" "D"

Logical comparisons

x <- 5

x > 3   # Greater than

[1] TRUE

x == 5  # Equal to (note: two equals signs!)

[1] TRUE

x != 3  # Not equal to

[1] TRUE

x <= 5  # Less than or equal to

[1] TRUE

Why version control?

What is Git?

What is GitHub?

Setting up Git

Check if Git is installed (in Terminal):

git --version

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Creating a GitHub account

1. Go to github.com
2. Create a free account
3. Choose a professional username

The Git workflow

1. Pull: Get the latest version from GitHub
2. Work: Make your changes
3. Stage: Select files to include in the snapshot
4. Commit: Take the snapshot with a message
5. Push: Upload to GitHub

Using Git in RStudio

RStudio has a Git pane that makes this easier:

1. Pull (blue down arrow): Get changes from GitHub
2. Stage (checkbox): Select files to commit
3. Commit (button): Open commit window
4. Push (green up arrow): Send to GitHub

Writing good commit messages

A commit message should explain what changed and why:

Add graphs to data section

- Added unemployment line chart
- Added inflation bar chart
- Updated figure references in text

The .gitignore file

Some files should not be tracked:

• Large data files (>100MB)
• Sensitive information
• Temporary files
• System files (.DS_Store)

# Ignore data files
*.csv
data/

# Ignore system files
.DS_Store

Connecting RStudio to GitHub

1. Create a Personal Access Token (PAT) on GitHub
2. In R, run:

# Install packages if needed
install.packages(c("usethis", "gitcreds"))

# Create a PAT (opens GitHub in browser)
usethis::create_github_token()

# Save your PAT
gitcreds::gitcreds_set()

Starting a new project with Git

Option 1: Create on GitHub first

1. Create new repo on GitHub
2. Copy the URL
3. In RStudio: File → New Project → Version Control → Git
4. Paste URL and create

# After creating an R Project
usethis::use_git()      # Initialise Git
usethis::use_github()   # Create GitHub repo

Don’t panic!

A reproducible workflow

Example project structure

assignment_1/
├── assignment_1.Rproj
├── README.md
├── .gitignore
├── inputs/
│   └── data/
│       └── raw_survey.csv
├── outputs/
│   ├── data/
│   │   └── cleaned_survey.csv
│   └── paper/
│       ├── assignment_1.qmd
│       └── references.bib
└── scripts/
    ├── 01-download_data.R
    └── 02-clean_data.R

Checklist for reproducibility

✅ Used an R Project (no setwd())

✅ All data loaded from files (not environment)

✅ All packages loaded at the start

✅ Code runs from top to bottom

✅ Results documented in Quarto

✅ Project tracked with Git/GitHub

✅ README explains how to run the code

This week’s readings

Key takeaways

1. Quarto combines code and text for reproducible documents
2. R Projects make your work portable and shareable
3. Folder structure keeps your project organised
4. Git and GitHub track changes and enable collaboration
5. read_csv() and write_csv() handle data files

Next week

Week 3: Data Acquisition and Measurement

• Understanding measurement properties
• Working with government data
• Accessing data through APIs
• Handling missing data

Questions?

References